#include "CamHandlerThread.h"
#include <iostream>

using namespace std;

CamHandlerThread::CamHandlerThread(CamHandler* camHandler, const int action, const int sleep):
	OpenThreads::Thread(), _quitflagC(false), _camHandler(camHandler), _actionC(action),
		 _sleepC(sleep) {}

CamHandlerThread::~CamHandlerThread() {
	#ifdef DEBUG
		cout << "----- Destruiert: CamHandlerThread -----" << endl;
	#endif
}

/*
 * run-Methode wird beim starten des Threads aufgerufen.
 * Entscheidet mittels des Integers action welche Aktion
 * ausgeführt werden soll. Jede Aktion ruft eine
 * Methode aus dem CamHandler auf. Über einen gemeinsamen
 * Mutex wird sichergestellt, dass immer nur ein Thread
 * gleichzeitig die Kamera ändern kann.
 */

void CamHandlerThread::run() {	    
	while (!_quitflagC) {
		_camHandler->getLockMutex()->lock();
		switch(_actionC)
			{
			case STEPFORWARD:
				_camHandler->stepForward();
				break;
			case STEPBACKWARD:
				_camHandler->stepBackward();
				break;
			case STEPLEFT:
				_camHandler->stepLeft();
				break;
			case STEPRIGHT:
				_camHandler->stepRight();
				break;
			case LOOKLEFT:
				_camHandler->lookLeft();
				break;
			case LOOKRIGHT:
				_camHandler->lookRight();
				break;
			case LOOKUP:
				_camHandler->lookUp();
				break;
			case LOOKDOWN:
				_camHandler->lookDown();
				break;
			case STEPUP:
				_camHandler->stepUp();
				break;
			case STEPDOWN:
				_camHandler->stepDown();
				break;
			case SWITCHCLIP:
				_camHandler->clipSwitch();
				_quitflagC = true;
				break;
			default:
				#ifdef DEBUG
				cout << "Unknown command!" << endl;
				#endif
				break;
			}
			_camHandler->getLockMutex()->unlock();
			OpenThreads::Thread::microSleep(_sleepC);
		}
	}

/*
 * Resettet das quitFlag
 */

void CamHandlerThread::reset(){
	_quitmutexC.lock();
	_quitflagC = false;
	_quitmutexC.unlock();
}	

/*
 * Beendet den Thread über setzen eines quitFlags
 */
	
void CamHandlerThread::quit() {	
	_quitmutexC.lock();
	_quitflagC = true;
	_quitmutexC.unlock();	
}
